package lin

import (
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strings"
	"sync"
	"time"
)

// 6666777
func NewL列表(是否_线程安全 ...bool) (返回_列表 L列表) {
    var 锁 *sync.RWMutex
    if len(是否_线程安全) > 0 && 是否_线程安全[0] {
        锁 = &sync.RWMutex{}
    }
    return L列表{
        原始数据: make([]any, 0),
        读写许可: 锁,
    }
}
func NewL列表_直接赋值(是否_线程安全 bool, 值 ...any) (返回_列表 L列表, 返回错误 error) {
	var 锁 *sync.RWMutex
    if 是否_线程安全 {
        锁 = &sync.RWMutex{}
    }
    列表 := L列表{
        原始数据: make([]any, 0),
        读写许可: 锁,
    }
    err := 列表.T添加值(值...)
    return 列表, err
	
}

type L列表 struct {
	原始数据 []any
	读写许可 *sync.RWMutex
}

func (类 *L列表) 初始化() {
	if 类.原始数据 == nil {
		类.原始数据 = make([]any, 0)
	}
}

func (类 *L列表) ZX置线程安全() {
	if 类.读写许可 == nil {
		var 锁 sync.RWMutex
		类.读写许可 = &锁
	}
}

// @ 支持 json && []any && L列表 &&[]基本类型 && 可以json化的切片
func (类 *L列表) ZR载入(载入值 any) (返回_错误 error) {
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	类.原始数据 = make([]any, 0)
	switch 当前值 := 载入值.(type) {
	case string:
		返回_错误 = json.Unmarshal([]byte(当前值), &类.原始数据)
		return
	case []any:
		返回_错误 = 键值列表_类型筛选(当前值)
		if 返回_错误 != nil {
			return
		}
		新值, _ := 键值列表_深拷贝(当前值)
		类.原始数据, _ = 新值.([]any)
		return
	case L列表:
		if &类.原始数据 == &当前值.原始数据 {
			返回_错误 = errors.New("错误:自己不能载入自己")
			return
		}
		类.原始数据 = 当前值.D到切片()
		return
	case []int:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []bool:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []float64:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []float32:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []int8:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []int16:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []int32:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []int64:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []uint:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []uint16:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []uint32:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []uint64:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []byte:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []time.Time:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	case []string:
		类.原始数据 = 列表载入辅助类型转换(当前值)
		return
	default:
		JSON, err := json.Marshal(载入值)
		if err != nil {
			返回_错误 = err
			return
		}
		返回_错误 = json.Unmarshal([]byte(JSON), &类.原始数据)
		return
	}

}
func 列表载入辅助类型转换[T any](参数 []T) []any {
	返回组 := make([]any, len(参数))
	for i, v := range 参数 {
		返回组[i] = v
	}
	return 返回组

}

// 列分割符 会将 数据分割成 []any  加了表分割符 会分割成[]map[string]any
func (类 *L列表) C从文本分割(文本 string, 列分割符 string, 表分割符 ...string) (返回_错误 error) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	类.原始数据 = make([]any, 0)
	表分符 := ""
	if len(表分割符) > 0 {
		表分符 = 表分割符[0]
	}

	分割组 := 全_文本.F分割文本(文本, 列分割符)
	原始数据 := make([]any, len(分割组))
	for i, v := range 分割组 {
		if 表分符 != "" {
			var 表 J键值表
			表组 := 全_文本.F分割文本(v, 表分符)
			var 转换组 = make([]any, len(表组))
			for ii, vv := range 表组 {
				转换组[ii] = vv
			}
			if len(转换组) > 0 {
				返回_错误 = 表.C创建(转换组...)
				if 返回_错误 != nil {
					return
				}
				原始数据[i] = 表.D到map()

			} else {
				原始数据[i] = 表.D到map()
			}

		} else {
			原始数据[i] = v
		}

	}

	类.原始数据 = 原始数据
	return
}
func (类 *L列表) D到切片() (返回_值 []any) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	新值, _ := 键值列表_深拷贝(类.原始数据)
	返回_值, _ = 新值.([]any)
	return
}
func (类 *L列表) Q清空() bool {
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	类.原始数据 = make([]any, 0)
	return true
}
func (类 *L列表) D到JSON() (返回_值 string) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}

	新值, _ := 键值列表_深拷贝(类.原始数据)
	转换数据 := 键值列表_JSON之前处理(新值)
	JSON, err := json.Marshal(转换数据)
	if err != nil {
		返回_值 = "[]"
		return
	}
	返回_值 = string(JSON)
	return
}

func (类 *L列表) D到新列表() (返回_值 L列表) {
	返回_值.Q清空()
	类.初始化()
	if 类.读写许可 != nil {
		if &类.读写许可 == &返回_值.读写许可 {
			return
		}
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	返回_值.ZR载入(类.原始数据)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) Q取值(路径或索引 any, 索引 ...any) (返回_值 any, 返回_错误 error) {
	路径组, err := 值列路径(路径或索引, 索引...)
	if err != nil {
		返回_错误 = err
		return
	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}

	返回_值, 返回_错误 = 键值列表_取值(类.原始数据, 路径组)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) QW取文本(路径或索引 any, 索引 ...any) (返回_值 string) {
	值, 返回_错误 := 类.Q取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	返回_值 = any_到文本(值)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) QZ取整数(路径或索引 any, 索引 ...any) (返回_值 int) {
	值, _ := 类.Q取值(路径或索引, 索引...)
	返回_值 = 全_类型.D到整数(值)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) QX取小数(路径或索引 any, 索引 ...any) (返回_值 float64) {
	值, _ := 类.Q取值(路径或索引, 索引...)
	返回_值 = 全_类型.D到双精度小数(值)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) QL取逻辑值(路径或索引 any, 索引 ...any) (返回_值 bool) {
	值, _ := 类.Q取值(路径或索引, 索引...)
	返回_值 = 全_类型.D到逻辑值(值)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 LB_列表 则走 路径+索引 混合
func (类 *L列表) QM取map(路径或索引 any, 索引 ...any) (返回_值 map[string]any) {
	值, _ := 类.Q取值(路径或索引, 索引...)
	返回_值, _ = 值.(map[string]any)
	return

}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) QJ取键值表(路径或索引 any, 索引 ...any) (返回_值 J键值表) {
	返回_值.Q清空()
	值, 返回_错误 := 类.Q取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	// 新值, OK := 值.(map[string]any)
	// if !OK {
	// 	return
	// }
	返回_值.ZR载入(值)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) QQ取切片(路径或索引 any, 索引 ...any) (返回_值 []any) {
	值, _ := 类.Q取值(路径或索引, 索引...)
	返回_值, _ = 值.([]any)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) QL取列表(路径或索引 any, 索引 ...any) (返回_值 L列表) {
	返回_值.Q清空()
	值, 返回_错误 := 类.Q取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	返回_值.ZR载入(值)
	return
	// switch 当前值 := 值.(type) {
	// case []any:
	// 	返回_值.ZR载入(当前值)
	// 	return
	// default:
	// 	//返回_错误 = errors.New("错误:被取值的类型不是[]any")
	// 	return
	// }
}
func (类 *L列表) QZ取字节集(路径或索引 any, 索引 ...any) (返回_值 []byte) {
	值, 返回_错误 := 类.Q取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	switch 当前值 := 值.(type) {
	case []byte:
		返回_值 = 当前值
		return
	default:
		返回_值 = 全_类型.D到字节集(当前值)
		return
	}
}

func (类 *L列表) QS取时间日期(路径或索引 any, 索引 ...any) (返回_值 time.Time) {
	值, 返回_错误 := 类.Q取值(路径或索引, 索引...)
	if 返回_错误 != nil {
		return
	}
	返回_值 = 全_类型.D到时间(值)
	return
}
func (类 *L列表) QS取数量() int {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	return len(类.原始数据)
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) Z置值(添加值 any, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	路径组, err := 值列路径(路径或索引, 索引...)
	if err != nil {
		返回_错误 = err
		return
	}
	if 新值, ok := 添加值.(J键值表); ok {
		添加值 = 新值.D到map()
	} else if 新值, ok := 添加值.(L列表); ok {
		添加值 = 新值.D到切片()
	}

	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}

	返回_错误 = 键值列表_置值(类.原始数据, 路径组, 添加值)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZZ置子切片_添加(添加值 any, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	路径组, err := 值列路径(路径或索引, 索引...)
	if err != nil {
		返回_错误 = err
		return
	}
	if 新值, ok := 添加值.(J键值表); ok {
		添加值 = 新值.D到map()
	} else if 新值, ok := 添加值.(L列表); ok {
		添加值 = 新值.D到切片()
	}

	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}

	返回_错误 = 键值列表_子切片添加值(类.原始数据, 路径组, 添加值)
	return
}

// 单个 或 按顺序 连续添加
func (类 *L列表) T添加值(添加值 ...any) (返回_错误 error) {
	for i, v := range 添加值 {
		if 新值, ok := v.(J键值表); ok {
			赋值 := 新值.D到map()
			添加值[i] = 赋值
		} else if 新值, ok := v.(L列表); ok {
			赋值 := 新值.D到切片()
			添加值[i] = 赋值
		} else {
			返回_错误 = 键值列表_类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}

	}

	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	新值, _ := 键值列表_深拷贝(添加值)
	新切片, ok := 新值.([]any)
	if !ok {
		返回_错误 = errors.New("错误,添加失败")
		return
	}
	类.原始数据 = append(类.原始数据, 新切片...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZW置文本(添加值 string, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZZ置整数(添加值 int, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZX置小数(添加值 float64, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZL置逻辑(添加值 bool, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZZ置字节集(添加值 []byte, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZS置时间日期(添加值 time.Time, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZM置map(添加值 map[string]any, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}
func (类 *L列表) ZJ置键值表(添加值 J键值表, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
func (类 *L列表) ZQ置切片(添加值 []any, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

func (类 *L列表) ZL置列表(添加值 L列表, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}

// 路径  用 . 分割  自动去除 前后包裹的 []  如 路径1.路径2.[0].路径4 | 路径1.路径2.0.路径4|路径1.[路径2].0.路径4"
// 索引 如果 后面索引不为空 则走 路径+索引 混合
// 自动会把 []map[string]any 转换成 []any
func (类 *L列表) ZM置map组(添加值 []map[string]any, 路径或索引 any, 索引 ...any) (返回_错误 error) {
	返回_错误 = 类.Z置值(添加值, 路径或索引, 索引...)
	return
}
func (类 *L列表) S删值(路径或索引 any, 索引 ...any) (返回_错误 error) {
	路径组, err := 值列路径(路径或索引, 索引...)
	if err != nil {
		返回_错误 = err
		return
	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}

	返回值, 返回_错误 := 键值列表_删除值(类.原始数据, 路径组)
	if 值, ok := 返回值.([]any); ok && 返回_错误 == nil {
		类.原始数据 = 值
	}
	return
}
func (类 *L列表) ZR载入_重文件(文件路径 string) (返回_错误 error) {
	var data []byte
	data, 返回_错误 = 全_文件.D读入_文件(文件路径)
	if 返回_错误 != nil {
		return
	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	返回_错误 = json.Unmarshal(data, &类.原始数据)
	if 返回_错误 != nil {
		return
	}
	return
}

func (类 *L列表) B保存_到文件(文件路径 string) (返回_错误 error) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	新值, _ := 键值列表_深拷贝(类.原始数据)
	转换数据 := 键值列表_JSON之前处理(新值)
	JSON, err := json.Marshal(转换数据)
	if err != nil {
		返回_错误 = err
		return
	}
	返回_错误 = 全_文件.X写到_文件(文件路径, []byte(JSON))
	return
}

// 正常支持 列表里套键值表查询  如[]map[]   []any 类型查询  默认 键值="索引值" 如  索引值="无敌" and 索引值 !="哈哈"
// @ 逻辑判断符号 支持  "||" or OR,    "&& and ADN"
// @ 等式判断符号 支持  "~= LIKE  like (包含 支持 单个站位符号 % 如  键 like '%哈哈')",
// "!~= NOTLIKE  notlike (包含 支持 单个站位符号 % )", "<=", ">=", "!=", "=", ">", "<"
// @ 运算符   "=", "+", "-", "*", "/", "%"(求余数)
// @ 反回新列表
func (列表 *L列表) C查询(条件语句 string) (返回_列表 L列表, 返回_错误 error) {
	返回_列表.Q清空()
	返回_组 := make([]any, 0)
	分割条件 := []string{"||", "&&", "(", ")", "!~=", "~=", "<=", ">=", "!=", "=", "+", "-", "*", "/", "%", ">", "<"}
	条件切片 := 键值列表_条件分割(条件语句, 分割条件)
	for i, v := range 条件切片 {
		if v == "and" || v == "ADN" {
			条件切片[i] = "&&"
		} else if v == "or" || v == "OR" {
			条件切片[i] = "||"
		} else if v == "NOTLIKE" || v == "notlike" {
			条件切片[i] = "!~="
		} else if v == "LIKE" || v == "like" {
			条件切片[i] = "~="
		}

	}

	列表.初始化()
	if 列表.读写许可 != nil {
		列表.读写许可.RLock()
		defer 列表.读写许可.RUnlock()
	}
	for _, v := range 列表.原始数据 {
		添加组 := make([]string, len(条件切片))
		copy(添加组, 条件切片)
		switch 当前值 := v.(type) {
		case map[string]any:

			结果, err := m_map查询_带参数(分割条件, 添加组, 当前值)
			if err != nil {
				返回_错误 = err
				return
			}
			if 结果 {
				返回_组 = append(返回_组, 当前值)
			}
		default:
			新map := map[string]any{"索引值": 当前值}
			结果, err := m_map查询_带参数(分割条件, 添加组, 新map)
			if err != nil {
				返回_错误 = err
				return
			}
			if 结果 {
				返回_组 = append(返回_组, 新map)
			}
		}
	}
	返回_列表.ZR载入(返回_组)
	return
}

// []any 类型查询  默认 键值="索引值" 如  索引值="无敌" and 索引值 !="哈哈"
// @ 逻辑判断符号 支持  "||" or OR,    "&& and ADN"
// @ 等式判断符号 支持  "~= LIKE  like (包含 支持 单个站位符号 % 如  键 like '%哈哈')",
// "!~= NOTLIKE  notlike (包含 支持 单个站位符号 % )", "<=", ">=", "!=", "=", ">", "<"
// @ 运算符   "=", "+", "-", "*", "/", "%"(求余数)
// @ 位置  如果 没有对应 则返回 -1
func (类 *L列表) C查找_条件语句(条件语句 string, 开始位置 ...int) (返回_位置 int, 返回_错误 error) {
	判断开始位置 := 0
	返回_位置 = -1
	if len(开始位置) > 0 {
		判断开始位置 = 开始位置[0]
	}
	分割条件 := []string{"||", "&&", "(", ")", "!~=", "~=", "<=", ">=", "!=", "=", "+", "-", "*", "/", "%", ">", "<"}
	条件切片 := 键值列表_条件分割(条件语句, 分割条件)
	for i, v := range 条件切片 {
		if v == "and" || v == "ADN" {
			条件切片[i] = "&&"
		} else if v == "or" || v == "OR" {
			条件切片[i] = "||"
		} else if v == "NOTLIKE" || v == "notlike" {
			条件切片[i] = "!~="
		} else if v == "LIKE" || v == "like" {
			条件切片[i] = "~="
		}

	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	for i, v := range 类.原始数据 {
		添加组 := make([]string, len(条件切片))
		copy(添加组, 条件切片)
		if i < 判断开始位置 {
			continue
		}
		switch 当前值 := v.(type) {
		case map[string]any:
			结果, err := m_map查询_带参数(分割条件, 添加组, 当前值)
			if err != nil {
				返回_错误 = err

				return
			}
			if 结果 {
				返回_位置 = i
				return
			}
		default:
			新map := map[string]any{"索引值": 当前值}
			结果, err := m_map查询_带参数(分割条件, 添加组, 新map)
			if err != nil {
				返回_错误 = err
				return
			}
			if 结果 {
				返回_位置 = i
				return
			}
		}
	}
	return
}

// @ 主键名称=""的时候 直接查 普通切列表
func (类 *L列表) C查找(主键名称 string, 查找内容 any, 开始位置 ...int) (返回_位置 int) {
	文本值 := any_到文本(查找内容)
	判断开始位置 := 0
	返回_位置 = -1
	if len(开始位置) > 0 {
		判断开始位置 = 开始位置[0]
	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	if 主键名称 == "" {
		for i, v := range 类.原始数据 {
			if i < 判断开始位置 {
				continue
			}
			if v == 查找内容 || any_到文本(v) == 文本值 {
				返回_位置 = i
				return
			}

		}
	} else {
		for i, v := range 类.原始数据 {
			if i < 判断开始位置 {
				continue
			}
			switch 当前值 := v.(type) {
			case map[string]any:
				if 新值, ok := 当前值[主键名称]; ok && (新值 == 查找内容 || any_到文本(新值) == 文本值) {
					返回_位置 = i
					return
				}

			}

		}

	}

	return
}

// 类型 和 数据 完全一致的查找
// @ 主键名称=""的时候 直接查 普通切列表
func (类 *L列表) C查找_绝对匹配(主键名称 string, 查找内容 any, 开始位置 ...int) (返回_位置 int) {
	判断开始位置 := 0
	返回_位置 = -1
	if len(开始位置) > 0 {
		判断开始位置 = 开始位置[0]
	}
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}

	if 主键名称 == "" {
		for i, v := range 类.原始数据 {
			if i < 判断开始位置 {
				continue
			}
			if v == 查找内容 {
				返回_位置 = i
				return
			}

		}
	} else {

		for i, v := range 类.原始数据 {
			if i < 判断开始位置 {
				continue
			}
			switch 当前值 := v.(type) {
			case map[string]any:
				if 新值, ok := 当前值[主键名称]; ok && 新值 == 查找内容 {
					返回_位置 = i
					return
				}

			}

		}
	}

	return
}

// @唯一标识的键 就是用哪个键的值做索引  要值求唯一性 否则 会被最后一个 值的值替换
// {唯一标识的键的值:{原来列表数据}} 并且会在原数据键值表添加一个  "原列表位置" 的值 标明数据在原来列表的位置
// 只支持 []map[string]any
func (类 *L列表) QS取索引表(唯一标识的键 string) (返回_值 J键值表, 返回_错误 error) {
	返回_值.Q清空()
	返回_值.ZX置线程安全()
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	for i, v := range 类.原始数据 {
		switch 当前值 := v.(type) {
		case map[string]any:
			if 值, ok := 当前值[唯一标识的键]; ok {
				唯一值 := any_到文本(值)
				if 唯一值 != "" {
					当前值["原列表位置"] = i
					返回_值.Z置值(当前值, 唯一值)
				}
			} else {
				返回_错误 = errors.New("错误:唯一标识的键 出现不存在 ")
				return
			}
		default:
			返回_错误 = errors.New("错误:列表值类型错误  必须是 map[string]any")
			return
		}
	}
	return

}

func (类 *L列表) L连接到文本(合并连接符 string) (返回_值 string) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	切片 := make([]string, len(类.原始数据))
	for i, v := range 类.原始数据 {
		切片[i] = fmt.Sprintf("%v", v)
	}
	返回_值 = strings.Join(切片, 合并连接符)
	return
}

// 把其它列表的值合并过来  依次添加到列表后面
func (类 *L列表) H合并列表(参数列表 L列表) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	列表 := 参数列表.D到切片()
	类.原始数据 = append(类.原始数据, 列表...)
}

// 把其它列表的值合并成一个 新的返回列表  相同的会被替换, 没有的会添加进来(不影响原列表 )
func (类 *L列表) H合并列表_到新列表(参数列表 L列表) (返回列表 L列表, 返回错误 error) {
	if &返回列表.原始数据 == &类.原始数据 || &返回列表.原始数据 == &参数列表.原始数据 {
		返回错误 = errors.New("新列表 不能是原有列表")
		return
	}
	返回列表.Q清空()
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	新值, _ := 键值列表_深拷贝(类.原始数据)
	返回列表.ZR载入(新值)
	列表 := 参数列表.D到切片()
	返回列表.原始数据 = append(返回列表.原始数据, 列表...)
	return
}

// @键参数 排序条件的键  如果键参数="" 则按整切片排序
// @ 排序类型 1=文本 2=整数 3=浮点数 其他数 默认 文本
func (类 *L列表) P排序(键参数 string, 排序类型 int, 是否升序 bool) (返回错误 error) {
	if 排序类型 != 2 && 排序类型 != 3 {
		排序类型 = 1
	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}

	sort.SliceStable(类.原始数据, func(i, j int) bool {
		if 键参数 == "" {
			前数据 := 类.原始数据[i]
			后数据 := 类.原始数据[j]
			if 排序类型 == 2 {
				值1 := 全_类型.D到整数(前数据)
				值2 := 全_类型.D到整数(后数据)
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			} else if 排序类型 == 3 {
				值1 := 全_类型.D到双精度小数(前数据)
				值2 := 全_类型.D到双精度小数(后数据)
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			} else {
				值1 := 全_类型.D到文本(前数据)
				值2 := 全_类型.D到文本(后数据)
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			}

		} else {
			前数据 := 类.原始数据[i]
			前值, ok1 := 前数据.(map[string]any)
			后数据 := 类.原始数据[j]
			后值, ok2 := 后数据.(map[string]any)
			if !ok1 || !ok2 {
				return false
			}
			if 排序类型 == 2 {
				值1 := 全_类型.D到整数(前值[键参数])
				值2 := 全_类型.D到整数(后值[键参数])
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			} else if 排序类型 == 3 {
				值1 := 全_类型.D到双精度小数(前值[键参数])
				值2 := 全_类型.D到双精度小数(后值[键参数])
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			} else {
				值1 := 全_类型.D到文本(前值[键参数])
				值2 := 全_类型.D到文本(后值[键参数])
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			}

		}

	})

	return
}
